High-level real-time programming in Java

Real-time systems have reached a level of complexity beyond the scaling capability of the low-level or restricted languages traditionally used for real-time programming. While Metronome garbage collection has made it practical to use Java to implement real-time systems, many challenges remain for the construction of complex real-time systems, some specic to the use of Java and others simply due to the change in scale of such systems. The goal of our research is the creation of a comprehensive Java-based programming environment and methodology for the creation of complex real-time systems. Our goals include construction of a provably correct real-time garbage collec-tor capable of providing worst case latencies of 100 s, capa-ble of scaling from sensor nodes up to large multiprocessors; specialized programming constructs that retain the safety and simplicity of Java, and yet provide sub-microsecond la-tencies; the extension of Java's \write once, run anywhere" principle from functional correctness to timing behavior; on-line analysis and visualization that aids in the understanding of complex behaviors; and a principled probabilistic analy-sis methodology for bounding the behavior of the resulting systems. While much remains to be done, this paper describes the progress we have made towards these goals

Principles and Practices of Software Development

In this paper, we aim to provide a new perspective on the methods of software development. We find most software development methodologies to be overly prescriptive; they focus primarily on what methods to use without adequate consideration of what problems are being addressed and without a comparison of different methods that apply to the same problem. We maintain that software developers can be most effective if they are provided both with a variety of methods from which to choose and with the understanding necessary to select the methods that are best suited to their project. To that end, we introduce a framework for describing the principles of software development, a vocabulary for characterizing and understanding the constraints under which software is being written. We present some principles of software development, relating them to specific problems that occur in software projects and to practices that are used to address those problems. We observe that the practices of different methodologies can be understood in terms of how they weigh the relative importance of the underlying principles. We illustrate how identifying such principles can help in selecting the most appropriate practices. We note that some of the most significant differences among methodologies arise when principles provide conflicting viewpoints. We then discuss how iterative or incremental software development practices can be used to minimize the risks that result from conflicting principles. DRAFT of August 26, 2002 2

Space profiling for parallel functional programs

Abstract: "This paper presents a semantic space profiler for parallel functional programs. Building on previous work in sequential profiling, our tools help programmers to relate runtime resource use back to program source code. Unlike many profiling tools, our profiler is based on a cost semantics. This provides a means to reason about performance without requiring a detailed understanding of the compiler or runtime system. It also provides a specification for language implementers. This is critical in that it enables us to separate cleanly the performance of the application from that of the language implementation. Some aspects of the implementation can have significant effects on performance. Our cost semantics enables programmers to understand the impact of different scheduling policies yet abstracts away from many of the details of their implementations. We show applications where the choice of scheduling policy has asymptotic effects on space use. We explain these use patterns through a demonstration of our tools. We also validate our methodology by observing similar performance in our implementation of a parallel extension of Standard ML.

A Semantic Framework for Scheduling Parallel Programs

Abstract. Declarative parallel programs offer deterministic results, allowing the language implementation to schedule parallel tasks in any order. However, program performance hinges crucially on the way that these tasks are scheduled. In this work, we use formal language semantics to express different scheduling policies. These semantics enable us to compare different policies and to understand their effects on the use of space. We offer several example programs to demonstrate that scheduling policy can have a dramatic, and even asymptotic, effect on space usage. To predict performance, programmers require a means to understand the effects of scheduling. We define a cost semantics that allows programmers to reason about how space is used by parallel declarative programs. At the same time, these costs provide a specification for how implementations should behave.